package com.xbongbong.pro.enums.raiders.enums;

import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.xbongbong.i18n.util.I18nMessageUtil;
import com.xbongbong.paas.constant.PaasConstant;
import com.xbongbong.paas.constant.TimeConstant;
import lombok.Getter;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Objects;

/**
 * 价值攻略阶段枚举
 * @author zcp
 * @version v1.0
 * @date 19/9/18 018 20:49
 * @update 19/9/18 018 20:49
 * @since v1.0
 */
@Getter
public enum RaidersStageEnum {
    /**
     * 阶段枚举，对应数据库内stage字段
     * 到达该时间就展示，如购买30天后就展示该攻略一直到到期日期
     */
    UN_LIMIT(1, "enum.raidersStage.name.un_limit"),


    VIP_MONTH_ONE(2, "enum.raidersStage.name.vip_month_one"),


    VIP_MONTH_THREE(3, "enum.raidersStage.name.vip_month_three"),


    VIP_MONTH_SIX(4, "enum.raidersStage.name.vip_month_six"),


    VIP_EXPIRE_TO_BE(5, "enum.raidersStage.name.vip_expire_to_be"),


    UNKNOWN(404, "enum.raidersStage.name.unknown"),

    ;

    /**
     * 枚举值 --
     */
    private final int code;
    /**
     * 枚举信息--中文名称
     */
    private final String name;

    RaidersStageEnum(int code, String name) {
        this.code = code;
        this.name = name;
    }

    /**
     * 通过code获取枚举
     * @param code
     * @return com.xbongbong.pro.enums.raiders.enums.RaidersStageEnum
     * @author zcp
     * @date 19/9/19 019 14:42
     * @update 19/9/19 019 14:42
     * @since v1.0
     * @version v1.0
     */
    public static RaidersStageEnum getByCode(int code){
        for (RaidersStageEnum cache : values()) {
            if (Objects.equals(cache.code, code)) {
                return cache;
            }
        }
        //默认免费
        return UN_LIMIT;
    }

    /**
     * 格式化下拉选项
     * @return com.alibaba.fastjson.JSONArray
     * @author zcp
     * @date 19/9/21 021 14:29
     * @update 19/9/21 021 14:29
     * @since v1.0
     * @version v1.0
     */
    public static JSONArray formatOption() {
        JSONArray jsonArray = new JSONArray();
        for (RaidersStageEnum cache : values()) {
            if (Objects.equals(cache, UNKNOWN)) {
                continue;
            }
            JSONObject jsonObject = new JSONObject();
            jsonObject.put("key", cache.getCode());
            jsonObject.put("value", cache.getName());
            jsonArray.add(jsonObject);
        }
        return jsonArray;
    }

    /**
     * 根据套餐情况，得到能查看的攻略阶段list，规则如下：
     * （1）now < startTime 未到套餐时间，只有未限制阶段
     * （2）now >= expireTime 预计到期，则包含所有阶段(expireTime = endTime - TimeConstant.SECONDS_PER_MONTH
     * （3）now - startTime 大于半年（6个月时间），包含购买半年及之前的所有阶段，以此类推
     * @param startTime 套餐开始时间
     * @param endTime 套餐结束时间
     * @param now 当前时间
     * @return java.util.List<java.lang.Integer>
     * @author zcp
     * @date 19/9/24 024 17:17
     * @update 19/9/24 024 17:17
     * @since v1.0
     * @version v1.0
     */
    public static List<Integer> getStageList(Long startTime, Long endTime, Long now) {
        if (now <= startTime || now > endTime) {
            //当前时间还未到套餐开始时间、或套餐已经超过使用时间，则只能使用未限制阶段的攻略
            return Arrays.asList(RaidersStageEnum.UN_LIMIT.getCode());
        }
        //预计到期时间按照距离到期时间还有1个月时间时
        Long expireTime = endTime - TimeConstant.SECONDS_PER_MONTH;
        if (now >= expireTime) {
            //当前时间处于预计到期时间范围内，则获取到所有阶段（最小套餐也是1年，所以既然已经达到预计到期，则时间肯定超过了购买1个月、3个月、半年等）
            return RaidersStageEnum.getAllCode();
        }
        //使用时间 = 当前时间 - 套餐开始时间
        Long useTime = now - startTime;
        //从大到小判断，如：使用半年的肯定包含使用了1月、3月的情况
        RaidersStageEnum currentStageEnum;
        long sixMonth = (long)PaasConstant.COUNT_MONTH_SIX * TimeConstant.SECONDS_PER_MONTH;
        long threeMonth = (long)PaasConstant.COUNT_MONTH_THREE * TimeConstant.SECONDS_PER_MONTH;
        if (useTime >= sixMonth) {
            //截至到6个月
            currentStageEnum = VIP_MONTH_SIX;
        } else if (useTime >= threeMonth) {
            currentStageEnum = VIP_MONTH_THREE;
        } else {
            currentStageEnum = VIP_MONTH_ONE;
        }
        //得到截至到currentStageEnum的所有阶段
        List<Integer> stageList = getCodeToCurrent(currentStageEnum);
        return stageList;
    }

    /**
     * 获取所有阶段code
     * @return java.util.List<java.lang.Integer>
     * @author zcp
     * @date 19/9/24 024 16:15
     * @update 19/9/24 024 16:15
     * @since v1.0
     * @version v1.0
     */
    public static List<Integer> getAllCode() {
        List<Integer> stageList = new ArrayList<>();
        for (RaidersStageEnum cache : values()) {
            if (Objects.equals(cache, UNKNOWN)) {
                continue;
            }
            stageList.add(cache.code);
        }
        return stageList;
    }

    /**
     * 获取到当前阶段及以前的阶段code
     * @param currentStageEnum 要获取的当前阶段枚举
     * @return java.util.List<java.lang.Integer>
     * @author zcp
     * @date 19/9/24 024 16:24
     * @update 19/9/24 024 16:24
     * @since v1.0
     * @version v1.0
     */
    private static List<Integer> getCodeToCurrent(RaidersStageEnum currentStageEnum) {
        List<Integer> stageList = new ArrayList<>();
        for (RaidersStageEnum cache : values()) {
            if (Objects.equals(cache, UNKNOWN)) {
                continue;
            }
            stageList.add(cache.code);
            if (Objects.equals(cache, currentStageEnum)) {
                break;
            }
        }
        return stageList;
    }

    public String getName() {
        return I18nMessageUtil.getMessage(name);
    }
}